package utils;

/**
 * 
 */
import java.io.UnsupportedEncodingException;
import java.sql.*;
import java.util.*;

import com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException;

/**
 * @author angelorazrael
 * 
 */
public class Database {

	/**
	 * 内部使用的用于保存连接池中连接对象的�?此类中有两个成员，一个是数据库的连接，另�?��是指示此连接是否 正在使用的标志�?
	 */
	private class PooledConnection {
		private Connection connection = null;// 数据库连�?
		private boolean busyQuery = false; // 此连接是否正在使用的标志，默认没有正在使�?
		private boolean busyUpdate = false; // 此连接是否正在使用的标志，默认没有正在使�?
		private Statement statement;
		private ResultSet rs = null;

		// 构�?函数，根据一�?Connection 构告�?�� PooledConnection 对象
		private PooledConnection(Connection connection) {
			this.connection = connection;
			this.busyQuery = false; 
			this.busyUpdate = false; 
			this.statement = null;
			this.rs = null;
		}

		private int connection_execute_no_query(String query) {
			int affected = -1;
			try {
				Statement stmt = createStatement();
				affected = stmt.executeUpdate(query);
			} catch (SQLException e) {
				if(e instanceof MySQLIntegrityConstraintViolationException){
				
					return affected;
				}
				e.printStackTrace();
			}
			return affected;
		}

		private ResultSet connection_execute_single_command(String query) {
			try {
				Statement stmt = createStatement();
				rs = stmt.executeQuery(query);
			} catch (SQLException e) {
				e.printStackTrace();
			}

			return rs;
		}

		private Statement createStatement() {
			try {
				if (statement != null && !statement.isClosed())
					statement.close();
				statement = connection.createStatement();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return statement;
		}

		// 返回此对象中的连�?
		private Connection getConnection() {
			return connection;
		}

		// 获得对象连接是否�?
		private boolean isBusy() {
			try {
				if(rs == null || rs.isClosed())
					busyUpdate = false;
				else
					busyUpdate = true;
				
				return busyQuery || busyUpdate;
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return false;
		}
		
		// 设置对象的连接正在忙
		private void setBusy(boolean busy) {
			this.busyQuery = busy;
		}
		
		// 设置此对象的，连�?
		private void setConnection(Connection connection) {
			this.connection = connection;
		}
	}
	/**
	 * @author xujinghu
	 * @date 2012-12-1下午12:09:30
	 * @param rst
	 * @param type
	 * @param colNum
	 * @return 查询结果集中当前行colNum列type类型数据的字符串表示
	 * @throws Exception
	 */
	private static String getColumnValue(ResultSet rst,int type,int colNum)throws Exception
	   {
	      String ret="";
	      switch(type)
	      {
	         case(Types.CHAR):ret=rst.getString(colNum);break;
	         case(Types.INTEGER):ret=String.valueOf(rst.getInt(colNum));break;
	         case(Types.SMALLINT):ret=String.valueOf(rst.getInt(colNum));break;
	         case(Types.FLOAT):ret=String.valueOf(rst.getFloat(colNum));break;
	         case(Types.DOUBLE):ret=String.valueOf(rst.getDouble(colNum));break;
	         case(Types.VARCHAR):ret=rst.getString(colNum);break;
	         default:ret="Type not known";
	      }
	      return transEncode(ret);
	 }
	public static ArrayList<String> getRowValues(ResultSet rst) {
		ArrayList<String> row = new ArrayList<String>();
		try {
			ResultSetMetaData meta = rst.getMetaData();
			int col = meta.getColumnCount();
			
			for (int i = 1; i <= col; i++) {
				row.add(getColumnValue(rst,meta.getColumnType(i),i));
			}
			
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return row;
		
	}
	private static String transEncode(String chi) {
		String result = null;
		byte temp[];
		try {
			temp = chi.getBytes("iso-8859-1");
			result = new String(temp);
		} catch (UnsupportedEncodingException e) {
			System.out.println(e.toString());
		}
		return result;
	}
	/**
	 * @author xujinghu
	 * @date 2012-12-1下午12:56:11
	 * @param 数据类型的内部表示
	 * @return 数据类型名
	 */
	public static String typeToString(int i)
 {
		String ret = "";
		switch (i) {
		case (Types.CHAR):
			ret = "CHAR";
			break;
		case (Types.NUMERIC):
			ret = "NUMERIC";
			break;
		case (Types.DECIMAL):
			ret = "DECIMAL";
			break;
		case (Types.INTEGER):
			ret = "INTEGER";
			break;
		case (Types.SMALLINT):
			ret = "SMALLINT";
			break;
		case (Types.FLOAT):
			ret = "FLOAT";
			break;
		case (Types.DOUBLE):
			ret = "DOUBLE";
			break;
		case (Types.VARCHAR):
			ret = "VARCHAR";
			break;
		case (Types.DATE):
			ret = "DATE";
			break;
		default:
			ret = "other";
		}
		return ret;
	}
	private String jdbcDriver = ""; // 数据库驱�?
	private String dbUrl = ""; // 数据 URL
	private String dbUsername = ""; // 数据库用户名
	private String dbPassword = ""; // 数据库用户密�?
															private String testTable = ""; // 测试连接是否可用的测试表名，默认没有测试�?

	private int initialConnections = 1; // 连接池的初始大小

	private int incrementalConnections = 5;// 连接池自动增加的大小

	private int maxConnections = 50; // 连接池最大的大小

	private Vector<PooledConnection> connections = null; // 存放连接池中数据库连接的向量 ,

	// 初始时为 null,
															// 它中存放的对象为
															// PooledConnection
															// �?
	private boolean local_DB = true;

	/**
	 * 构�?函数
	 * 
	 * @param jdbcDriver
	 *            String JDBC 驱动类串,例如�?com.mysql.jdbc.Driver"
	 * @param dbUrl
	 *            String 数据�?URL，例如："jdbc:mysql://127.0.0.1:3306/antsoldier"
	 * @param dbUsername
	 *            String 连接数据库用户名
	 * @param dbPassword
	 *            String 连接数据库用户的密码
	 */
	public Database(String jdbcDriver, String dbUrl, String dbUsername,
			String dbPassword) {
		this.jdbcDriver = jdbcDriver;
		this.dbUrl = dbUrl;
		this.dbUsername = dbUsername;
		this.dbPassword = dbPassword;

		try {
			createPool();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 关闭�?��数据库连�?
	 * 
	 * @param �?��关闭的数据库连接
	 */
	private void closeConnection(Connection conn) {
		try {
			conn.close();
		} catch (SQLException e) {
			System.out.println(" 关闭数据库连接出错： " + e.getMessage());
		}
	}

	/**
	 * 
	 * 关闭连接池中�?��的连接，并清空连接池�?
	 */

	private synchronized void closeConnectionPool() throws SQLException {

		// 确保连接池存在，如果不存在，返回
		if (connections == null) {
			System.out.println(" 连接池不存在，无法关�?!");
			return;
		}
		PooledConnection pConn = null;
		Enumeration enumerate = connections.elements();

		while (enumerate.hasMoreElements()) {
			pConn = (PooledConnection) enumerate.nextElement();
			// 如果忙，�?5 �?
			if (pConn.isBusy()) {
				wait(5000); // �?5 �?
			}
			// 5 秒后直接关闭�?
			closeConnection(pConn.getConnection());
			// 从连接池向量中删除它
			connections.removeElement(pConn);
		}
		// 置连接池为空
		connections = null;

	}

	/**
	 * 创建�?numConnections 指定数目的数据库连接 , 并把这些连接 放入 connections 向量�?
	 * 
	 * @param numConnections
	 *            要创建的数据库连接的数目
	 */
	private void createConnections(int numConnections) throws SQLException {
		// 循环创建指定数目的数据库连接
		for (int x = 0; x < numConnections; x++) {
			// 是否连接池中的数据库连接的数量己经达到最大？�?��值由类成�?maxConnections
			// 指出，如�?maxConnections �?0 或负数，表示连接数量没有限制�?
			// 如果连接数己经达到最大，即�?出�?
			if (this.maxConnections > 0
					&& this.connections.size() >= this.maxConnections) {
				break;
			}

			// add a new PooledConnection object to connections vector
			// 增加�?��连接到连接池中（向量 connections 中）
			try {
				connections.addElement(new PooledConnection(newConnection()));
			} catch (SQLException e) {
				System.out.println(" 创建数据库连接失败！ " + e.getMessage());
				throw new SQLException();
			}
//			System.out.println(" 数据库连接己创建 ......");
		}
	}

	/**
	 * 创建�?��数据库连接池，连接池中的可用连接的数量采用类成员 initialConnections 中设置的�?
	 */
	private synchronized void createPool() throws Exception {
		// 确保连接池没有创�? 如果连接池己经创建了，保存连接的向量 connections 不会为空

		if (connections != null) {
			return; // 如果己经创建，则返回
		}

		// 实例�?JDBC Driver 中指定的驱动类实�?
		Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
		DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序
		// 创建保存连接的向�?, 初始时有 0 个元�?
		connections = new Vector<PooledConnection>();
		// 根据 initialConnections 中设置的值，创建连接�?
		createConnections(this.initialConnections);
//		System.out.println(dbUrl + " 数据库连接池创建成功�?");
	}

	/**
	 * @param Executes
	 *            a query in the database specified and returns the number of
	 *            affected rows (-1 on error)
	 * @return 执行成功�?
	 */
	public int database_execute_no_query(String query) {
		int affected = -1;
		try {
			PooledConnection pConn = getPooledConnection();	
//			System.out.println(query);
			affected = pConn.connection_execute_no_query(query);
			returnPooledConnection(pConn);
		} catch (SQLException e) {
			if (!(e instanceof MySQLIntegrityConstraintViolationException)) {
				e.printStackTrace();
			}
		}
		return affected;
	}

	/**
	 * 执行数据库查询操�?必须在调用本函数后手动关闭ResultSet，这样才能释放此次操作所使用的数据库连接�?
	 * @param 查询语句
	 * @return 结果集合
	 */
	public ResultSet database_execute_single_command(String query) {
		ResultSet rs = null;

		try {
			PooledConnection pConn = getPooledConnection();
			if ( ! "SELECT value as recovery FROM config WHERE conf = 'recovery'".equals(query) )
//				System.out.println(query);
			rs = pConn.connection_execute_single_command(query);
			returnPooledConnection(pConn);
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return rs;
	}

	/**
	 * 
	 * @param dbossim
	 * @param string
	 * @return 
	 * @author XiaYang
	 * @param dbossim 
	 */
	public long database_get_id(Database dbossim, String tableName) {
		
		ResultSet dm;

		Formatter formatter = new Formatter();
		formatter.format("UPDATE %s SET id=LAST_INSERT_ID(id+1)", tableName);
		String query = formatter.toString();
		
		database_execute_no_query (query);

		formatter = new Formatter();
		formatter.format("SELECT LAST_INSERT_ID(id) FROM %s", tableName);
		query = formatter.toString();

		dm = database_execute_single_command(query);
		long id = 0;
		try {
			if (dm.next())
				id = dm.getInt(1);
			else
				id = 0;
			dm.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return id;
	}

	public boolean database_is_local() {
		return local_DB;
	}

	/**
	 * 查找连接池中�?��的连接，查找�?��可用的数据库连接�?如果没有可用的连接，返回 null
	 * 
	 * @return 返回�?��可用的数据库连接
	 */
	private PooledConnection findFreePooledConnection() throws SQLException {
		Connection conn = null;
		PooledConnection pConn = null;
		// 获得连接池向量中�?��的对�?
		Enumeration<PooledConnection> enumerate = connections.elements();
		// 遍历�?��的对象，看是否有可用的连�?
		while (enumerate.hasMoreElements()) {
			pConn = (PooledConnection) enumerate.nextElement();
			if (!pConn.isBusy()) {
				// 如果此对象不忙，则获得它的数据库连接并把它设为忙				
				pConn.setBusy(true);
				conn = pConn.getConnection();
				// 测试此连接是否可�?
				if (!testConnection(conn)) {
					// 如果此连接不可再用了，则创建�?��新的连接�?
					// 并替换此不可用的连接对象，如果创建失败，返回 null
					try {
						conn = newConnection();
					} catch (SQLException e) {
						System.err.println(" 创建数据库连接失败！ " + e.getMessage());
						return null;
					}
					pConn.setConnection(conn);
				}
				return pConn; // 己经找到�?��可用的连接，返回
			}
		}
		return null;
	}

	/**
	 * 本函数从连接池向�?connections 中返回一个可用的的数据库连接，如�?当前没有可用的数据库连接，本函数则根�?
	 * incrementalConnections 设置 的�?创建几个数据库连接，并放入连接池中�? 如果创建后，�?��的连接仍都在使用中，则返�?null
	 * 
	 * @return 返回�?��可用的数据库连接
	 */

	private PooledConnection getFreePooledConnection() throws SQLException {

		// 从连接池中获得一个可用的数据库连�?
		PooledConnection pConn = findFreePooledConnection();
		if (pConn == null) {
			// 如果目前连接池中没有可用的连接，创建�?��连接
			createConnections(incrementalConnections);
			// 重新从池中查找是否有可用连接
			pConn = findFreePooledConnection();
		}
		return pConn;
	}

	/**
	 * 返回连接池自动增加的大小
	 * 
	 * @return 连接池自动增加的大小
	 */
	private int getIncrementalConnections() {
		return this.incrementalConnections;
	}

	/**
	 * 返回连接池的初始大小
	 * 
	 * @return 初始连接池中可获得的连接数量
	 */
	private int getInitialConnections() {
		return this.initialConnections;
	}
	
	/**
	 * 返回连接池中�?��的可用连接数�?
	 * 
	 * @return 连接池中�?��的可用连接数�?
	 */
	private int getMaxConnections() {
		return this.maxConnections;
	}

	/**
	 * 通过调用 getFreeConnection() 函数返回�?��可用的数据库连接 , 如果当前没有可用的数据库连接，并且更多的数据库连接不能创
	 * 建（如连接池大小的限制），此函数等待�?��再尝试获取�?
	 * 
	 * @return 返回�?��可用的数据库连接对象
	 */
	private synchronized PooledConnection getPooledConnection()
			throws SQLException {
		// 确保连接池己被创�?
		if (connections == null) {
			return null; // 连接池还没创建，则返�?null
		}

		PooledConnection pConn = getFreePooledConnection(); // 获得�?��可用的数据库连接
		// 如果目前没有可以使用的连接，即所有的连接都在使用�?
		while (pConn == null) {
			// 等一会再�?
			wait(250);
			pConn = getFreePooledConnection(); // 重新再试，直到获得可用的连接，如�?
			// getFreeConnection() 返回的为 null
			// 则表明创建一批连接后也不可获得可用连�?
		}

		return pConn;// 返回获得的可用的连接
	}

	/**
	 * 获取测试数据库表的名�?
	 * 
	 * @return 测试数据库表的名�?
	 */
	private String getTestTable() {
		return this.testTable;
	}

	/**
	 * 创建�?��新的数据库连接并返回�?
	 * 
	 * @return 返回�?��新创建的数据库连�?
	 */
	private Connection newConnection() throws SQLException {
		// 创建�?��数据库连�?
		Connection conn = DriverManager.getConnection(dbUrl, dbUsername,
				dbPassword);

		// 如果这是第一次创建数据库连接，即�?��数据库，获得此数据库允许支持�?
		// �?��客户连接数目
		// connections.size()==0 表示目前没有连接己被创建
		if (connections.size() == 0) {
			DatabaseMetaData metaData = conn.getMetaData();
			int driverMaxConnections = metaData.getMaxConnections();
			// 数据库返回的 driverMaxConnections 若为 0 ，表示此数据库没有最�?
			// 连接限制，或数据库的�?��连接限制不知�?
			// driverMaxConnections 为返回的�?��整数，表示此数据库允许客户连接的数目
			// 如果连接池中设置的最大连接数量大于数据库允许的连接数�?, 则置连接池的�?��
			// 连接数目为数据库允许的最大数�?

			if (driverMaxConnections > 0
					&& this.maxConnections > driverMaxConnections) {
				this.maxConnections = driverMaxConnections;
			}
		}

		return conn; // 返回创建的新的数据库连接
	}

	/**
	 * 刷新连接池中�?��的连接对�?
	 */
	private synchronized void refreshConnections() throws SQLException {

		// 确保连接池己创新存在
		if (connections == null) {
			System.out.println(" 连接池不存在，无法刷�?!");
			return;
		}
		PooledConnection pConn = null;
		Enumeration enumerate = connections.elements();

		while (enumerate.hasMoreElements()) {
			// 获得�?��连接对象
			pConn = (PooledConnection) enumerate.nextElement();
			// 如果对象忙则�?5 �?,5 秒后直接刷新
			if (pConn.isBusy()) {
				wait(5000); // �?5 �?
			}
			// 关闭此连接，用一个新的连接代替它�?
			closeConnection(pConn.getConnection());
			pConn.setConnection(newConnection());
			pConn.setBusy(false);
		}
	}

	/**
	 * 此函数返回一个数据库连接到连接池中，并把此连接置为空闲�? �?��使用连接池获得的数据库连接均应在不使用此连接时返回它�?
	 * 
	 * @param �?��回到连接池中的连接对�?
	 */
	private void returnPooledConnection(PooledConnection pConn) {
		// 确保连接池存在，如果连接没有创建（不存在），直接返回
		if (connections == null) {
			System.out.println(" 连接池不存在，无法返回此连接到连接池�?!");
			return;
		}

		pConn.setBusy(false);
	}

	/**
	 * 设置连接池自动增加的大小
	 * 
	 * @param 连接池自动增加的大小
	 */
	private void setIncrementalConnections(int incrementalConnections) {
		this.incrementalConnections = incrementalConnections;
	}

	/**
	 * 设置连接池的初始大小
	 * 
	 * @param 用于设置初始连接池中连接的数�?
	 */
	private void setInitialConnections(int initialConnections) {
		this.initialConnections = initialConnections;
	}

	/**
	 * 设置连接池中�?��可用的连接数�?
	 * 
	 * @param 设置连接池中�?��可用的连接数量�?
	 */
	private void setMaxConnections(int maxConnections) {
		this.maxConnections = maxConnections;
	}
	
	/**
	 * 设置测试表的名字
	 * 
	 * @param testTable
	 *            String 测试表的名字
	 */
	private void setTestTable(String testTable) {
		this.testTable = testTable;
	}
	
	
	/**
	 * 测试�?��连接是否可用，如果不可用，关掉它并返�?false 否则可用返回 true
	 * 
	 * @param conn
	 *            �?��测试的数据库连接
	 * @return 返回 true 表示此连接可用， false 表示不可�?
	 */
	private boolean testConnection(Connection conn) {
		try {
			// 判断测试表是否存�?
			if (testTable.equals("")) {
				// 如果测试表为空，试着使用此连接的 setAutoCommit() 方法
				// 来判断连接否可用（此方法只在部分数据库可用，如果不可�?,
				// 抛出异常）�?注意：使用测试表的方法更可靠
				conn.setAutoCommit(true);
			} else {// 有测试表的时候使用测试表测试
				// check if this connection is valid
				Statement stmt = conn.createStatement();
				stmt.execute("select count(*) from " + testTable);
			}

		} catch (SQLException e) {
			// 上面抛出异常，此连接己不可用，关闭它，并返回 false;
			closeConnection(conn);
			return false;
		}
		// 连接可用，返�?true
		return true;
	}
	
	/**
	 * 使程序等待给定的毫秒�?
	 * 
	 * @param 给定的毫秒数
	 */
	private void wait(int mSeconds) {
		try {
			Thread.sleep(mSeconds);
		} catch (InterruptedException e) {
		}
	}
}
